package com.hello.web.utils;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SessionCallback;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author neo
 * @date 2025-03-07
 * @description Redis 常用工具类
 **/
@Component
public class RedisUtils {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;


    /**
     * 删除指定键
     * @param key 键名
     * @return true表示删除成功，false表示键不存在
     */
    public Boolean delete(String key) {
        return redisTemplate.delete(key);
    }

    /**
     * 批量删除键
     * @param keys 键集合
     * @return 实际删除的键数量
     */
    public Long delete(List<String> keys) {
        return redisTemplate.delete(keys);
    }


    /**
     * 设置键的过期时间
     * @param key 键名
     * @param timeout 时间数值
     * @param unit 时间单位（秒/分钟/小时等）
     * @return true表示设置成功，false表示键不存在或设置失败
     */
    public Boolean expire(String key, long timeout, TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 获取键的剩余过期时间
     * @param key 键名
     * @return 剩余时间（秒），-2表示键不存在，-1表示永久有效
     */
    public Long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断键是否存在
     * @param key 键名
     * @return true存在，false不存在
     */
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }


// ---------------------- String 操作 ----------------------

    /**
     * 设置键值（永久有效）
     * @param key 键名
     * @param value 存储值，支持任意可序列化对象
     */
    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 设置键值并指定过期时间
     * @param key 键名
     * @param value 存储值
     * @param timeout 时间数值
     * @param unit 时间单位
     */
    public void set(String key, Object value, long timeout, TimeUnit unit) {
        redisTemplate.opsForValue().set(key, value, timeout, unit);
    }

    /**
     * 获取键值并自动反序列化
     * @param key 键名
     * @param clazz 目标类型Class对象
     * @return 值对象，类型不匹配时返回null
     */
    public <T> T get(String key, Class<T> clazz) {
        Object value = redisTemplate.opsForValue().get(key);
        return clazz.isInstance(value) ? clazz.cast(value) : null;
    }

    /**
     * 对数值类型的值进行递增
     * @param key 键名
     * @param delta 递增幅度（正数）
     * @return 递增后的新值
     */
    public Long increment(String key, long delta) {
        return redisTemplate.opsForValue().increment(key, delta);
    }

    // ---------------------- Hash 操作 ----------------------

    /**
     * 设置哈希表字段值
     * @param key 哈希表键名
     * @param hashKey 字段名
     * @param value 字段值
     */
    public void hPut(String key, String hashKey, Object value) {
        redisTemplate.opsForHash().put(key, hashKey, value);
    }

    /**
     * 批量设置哈希表字段
     * @param key 哈希表键名
     * @param map 字段键值对集合
     */
    public void hPutAll(String key, Map<String, ?> map) {
        redisTemplate.opsForHash().putAll(key, map);
    }

    /**
     * 获取哈希表字段值
     * @param key 哈希表键名
     * @param hashKey 字段名
     * @param clazz 目标类型Class对象
     * @return 字段值，类型不匹配返回null
     */
    public <T> T hGet(String key, String hashKey, Class<T> clazz) {
        Object value = redisTemplate.opsForHash().get(key, hashKey);
        return clazz.isInstance(value) ? clazz.cast(value) : null;
    }

    /**
     * 获取整个哈希表
     * @param key 哈希表键名
     * @return Map结构的所有字段和值
     */
    public Map<String, Object> hGetAll(String key) {
        return redisTemplate.<String, Object>opsForHash().entries(key);
    }

    /**
     * 删除哈希表字段
     * @param key 哈希表键名
     * @param hashKeys 要删除的字段数组
     * @return 实际删除的字段数量
     */
    public Long hDelete(String key, Object... hashKeys) {
        return redisTemplate.opsForHash().delete(key, hashKeys);
    }

    /**
     * 判断哈希表是否存在字段
     * @param key 哈希表键名
     * @param hashKey 字段名
     * @return true存在，false不存在
     */
    public Boolean hHasKey(String key, String hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }

    /**
     * 获取哈希表字段数量
     * @param key 哈希表键名
     * @return 字段总数
     */
    public Long hSize(String key) {
        return redisTemplate.opsForHash().size(key);
    }

    // ---------------------- List 操作 ----------------------

    /**
     * 左端插入元素（队列头）
     * @param key 列表键名
     * @param value 插入值
     * @return 插入后列表长度
     */
    public Long lPush(String key, Object value) {
        return redisTemplate.opsForList().leftPush(key, value);
    }

    /**
     * 批量左端插入
     * @param key 列表键名
     * @param values 值集合
     * @return 插入后列表长度
     */
    public Long lPushAll(String key, Collection<?> values) {
        return redisTemplate.opsForList().leftPushAll(key, values);
    }

    /**
     * 右端插入元素（队列尾）
     * @param key 列表键名
     * @param value 插入值
     * @return 插入后列表长度
     */
    public Long rPush(String key, Object value) {
        return redisTemplate.opsForList().rightPush(key, value);
    }

    /**
     * 左端弹出元素
     * @param key 列表键名
     * @param clazz 返回值类型Class
     * @return 元素对象，类型不匹配返回null
     */
    public <T> T lPop(String key, Class<T> clazz) {
        Object value = redisTemplate.opsForList().leftPop(key);
        return clazz.isInstance(value) ? clazz.cast(value) : null;
    }

    /**
     * 右端弹出元素
     * @param key 列表键名
     * @param clazz 返回值类型Class
     * @return 元素对象，类型不匹配返回null
     */
    public <T> T rPop(String key, Class<T> clazz) {
        Object value = redisTemplate.opsForList().rightPop(key);
        return clazz.isInstance(value) ? clazz.cast(value) : null;
    }

    /**
     * 获取列表指定范围元素
     * @param key 列表键名
     * @param start 起始索引（包含）
     * @param end 结束索引（包含）
     * @return 元素集合（未反序列化）
     */
    public List<Object> lRange(String key, long start, long end) {
        return redisTemplate.opsForList().range(key, start, end);
    }

    /**
     * 获取列表长度
     * @param key 列表键名
     * @return 元素总数
     */
    public Long lSize(String key) {
        return redisTemplate.opsForList().size(key);
    }

    // ---------------------- Set 操作 ----------------------

    /**
     * 向集合添加元素
     * @param key 集合键名
     * @param values 元素数组
     * @return 成功添加的新元素数量
     */
    public Long sAdd(String key, Object... values) {
        return redisTemplate.opsForSet().add(key, values);
    }

    /**
     * 获取集合所有元素
     * @param key 集合键名
     * @return 元素集合（未反序列化）
     */
    public Set<Object> sMembers(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 判断元素是否在集合中
     * @param key 集合键名
     * @param value 查询值
     * @return true存在，false不存在
     */
    public Boolean sIsMember(String key, Object value) {
        return redisTemplate.opsForSet().isMember(key, value);
    }

    /**
     * 删除集合元素
     * @param key 集合键名
     * @param values 元素数组
     * @return 成功删除的元素数量
     */
    public Long sRemove(String key, Object... values) {
        return redisTemplate.opsForSet().remove(key, values);
    }

    /**
     * 获取集合元素总数
     * @param key 集合键名
     * @return 元素数量
     */
    public Long sSize(String key) {
        return redisTemplate.opsForSet().size(key);
    }

    // ---------------------- ZSet 操作 ----------------------

    /**
     * 向有序集合添加元素
     * @param key 有序集合键名
     * @param value 元素值
     * @param score 排序分数
     * @return true表示新元素添加成功，false表示元素已存在
     */
    public Boolean zAdd(String key, Object value, double score) {
        return redisTemplate.opsForZSet().add(key, value, score);
    }

    /**
     * 按分数范围获取元素（闭区间）
     * @param key 有序集合键名
     * @param min 最小分数
     * @param max 最大分数
     * @return 元素集合（按分数升序排列）
     */
    public Set<Object> zRangeByScore(String key, double min, double max) {
        return redisTemplate.opsForZSet().rangeByScore(key, min, max);
    }

    /**
     * 增加元素的分数值
     * @param key 有序集合键名
     * @param value 元素值
     * @param delta 增量值
     * @return 更新后的分数值
     */
    public Double zIncrementScore(String key, Object value, double delta) {
        return redisTemplate.opsForZSet().incrementScore(key, value, delta);
    }

    /**
     * 删除有序集合元素
     * @param key 有序集合键名
     * @param values 元素数组
     * @return 成功删除的元素数量
     */
    public Long zRemove(String key, Object... values) {
        return redisTemplate.opsForZSet().remove(key, values);
    }

    /**
     * 获取元素排名（升序排名，从0开始）
     * @param key 有序集合键名
     * @param value 元素值
     * @return 排名序号，null表示元素不存在
     */
    public Long zRank(String key, Object value) {
        return redisTemplate.opsForZSet().rank(key, value);
    }

    /**
     * 获取有序集合元素总数
     * @param key 有序集合键名
     * @return 元素数量
     */
    public Long zSize(String key) {
        return redisTemplate.opsForZSet().size(key);
    }


    // ---------------------- 事务操作 ----------------------
    /**
     * 执行Redis事务
     * @param sessionCallback 事务会话回调
     * @return 事务执行结果
     * 使用示例：
     * List<Object> results = (List<Object>) redisUtil.executeTransaction(new SessionCallback<>() {
     *     @Override
     *     public Object execute(RedisOperations operations) {
     *         operations.multi();
     *         operations.opsForValue().set("key1", "value1");
     *         operations.opsForValue().increment("counter");
     *         return operations.exec();
     *     }
     * });
     */
    public Object executeTransaction(SessionCallback<?> sessionCallback) {
        return redisTemplate.execute(sessionCallback);
    }
}
